💪 Esercitazione OOP in Python

class Studente:
    """Rappresenta uno studente universitario con i suoi voti."""
    
    def __init__(self, nome, cognome, matricola):
        """
        Inizializza uno studente.
        
        Args:
            nome (str): Nome dello studente
            cognome (str): Cognome dello studente
            matricola (str): Matricola univoca
        """
        self.nome = nome
        self.cognome = cognome
        self.matricola = matricola
        self.voti = []  # Lista vuota per i voti
    
    def aggiungi_voto(self, voto):
        """
        Aggiunge un voto alla lista se valido (18-30).
        
        Args:
            voto (int): Il voto da aggiungere
        
        Returns:
            bool: True se il voto è stato aggiunto, False altrimenti
        """
        if 18 <= voto <= 30:
            self.voti.append(voto)
            print(f"✅ Voto {voto} aggiunto con successo!")
            return True
        else:
            print(f"❌ Voto {voto} non valido! Deve essere tra 18 e 30.")
            return False
    
    def media_voti(self):
        """
        Calcola la media dei voti.
        
        Returns:
            float: La media dei voti, 0 se non ci sono voti
        """
        if len(self.voti) == 0:
            return 0
        return sum(self.voti) / len(self.voti)
    
    def __str__(self):
        """Rappresentazione testuale dello studente."""
        media = self.media_voti()
        return f"Studente: {self.nome} {self.cognome} (Matricola: {self.matricola}) - Media: {media:.2f}"


# Test della classe
if __name__ == "__main__":
    studente = Studente("Mario", "Rossi", "12345")
    
    studente.aggiungi_voto(28)
    studente.aggiungi_voto(30)
    studente.aggiungi_voto(25)
    studente.aggiungi_voto(15)  # Questo non verrà aggiunto (non valido)
    
    print(studente)
    print(f"Media: {studente.media_voti():.2f}")

class ContoBancario:
    """Rappresenta un conto corrente bancario."""
    
    def __init__(self, titolare, saldo_iniziale=0.0):
        """
        Inizializza un conto bancario.
        
        Args:
            titolare (str): Nome del titolare del conto
            saldo_iniziale (float): Saldo iniziale del conto (default: 0.0)
        """
        self.titolare = titolare
        self._saldo = saldo_iniziale  # Attributo protetto
    
    def deposita(self, importo):
        """
        Deposita denaro sul conto.
        
        Args:
            importo (float): L'importo da depositare
        
        Returns:
            bool: True se operazione riuscita, False altrimenti
        """
        if importo <= 0:
            print(f"❌ Importo non valido: €{importo:.2f}")
            return False
        
        self._saldo += importo
        print(f"✅ Depositati €{importo:.2f} - Nuovo saldo: €{self._saldo:.2f}")
        return True
    
    def preleva(self, importo):
        """
        Preleva denaro dal conto.
        
        Args:
            importo (float): L'importo da prelevare
        
        Returns:
            bool: True se operazione riuscita, False altrimenti
        """
        if importo <= 0:
            print(f"❌ Importo non valido: €{importo:.2f}")
            return False
        
        if self._saldo < importo:
            print(f"❌ Fondi insufficienti! Saldo: €{self._saldo:.2f}, Richiesto: €{importo:.2f}")
            return False
        
        self._saldo -= importo
        print(f"✅ Prelevati €{importo:.2f} - Nuovo saldo: €{self._saldo:.2f}")
        return True
    
    def get_saldo(self):
        """
        Restituisce il saldo corrente.
        
        Returns:
            float: Il saldo del conto
        """
        return self._saldo
    
    def __str__(self):
        """Rappresentazione testuale del conto."""
        return f"Conto di {self.titolare} - Saldo: €{self._saldo:.2f}"


# Test della classe
if __name__ == "__main__":
    conto = ContoBancario("Laura Bianchi", 1000.0)
    print(conto)
    print()
    
    conto.deposita(500)
    conto.preleva(200)
    conto.preleva(2000)  # Fallirà
    conto.deposita(-100)   # Fallirà
    
    print()
    print(conto)
    print(f"Saldo finale: €{conto.get_saldo():.2f}")

class Prodotto:
    """Rappresenta un prodotto in un negozio con gestione sconto."""
    
    def __init__(self, nome, prezzo, quantita=0):
        """
        Inizializza un prodotto.
        
        Args:
            nome (str): Nome del prodotto
            prezzo (float): Prezzo unitario
            quantita (int): Quantità in magazzino
        """
        self.nome = nome
        self._prezzo = 0  # Inizializziamo a 0
        self.prezzo = prezzo  # Usiamo il setter per validazione
        self.quantita = quantita
        self._sconto_percentuale = 0
    
    # Property per il prezzo
    @property
    def prezzo(self):
        """Restituisce il prezzo del prodotto."""
        return self._prezzo
    
    @prezzo.setter
    def prezzo(self, valore):
        """
        Imposta il prezzo con validazione.
        
        Args:
            valore (float): Il nuovo prezzo
        
        Raises:
            ValueError: Se il prezzo non è positivo
        """
        if valore <= 0:
            raise ValueError(f"Il prezzo deve essere positivo, ricevuto: €{valore:.2f}")
        self._prezzo = valore
    
    # Property per lo sconto
    @property
    def sconto_percentuale(self):
        """Restituisce lo sconto percentuale."""
        return self._sconto_percentuale
    
    @sconto_percentuale.setter
    def sconto_percentuale(self, valore):
        """
        Imposta lo sconto con validazione.
        
        Args:
            valore (float): Lo sconto in percentuale (0-100)
        
        Raises:
            ValueError: Se lo sconto non è tra 0 e 100
        """
        if not 0 <= valore <= 100:
            raise ValueError(f"Lo sconto deve essere tra 0 e 100, ricevuto: {valore}%")
        self._sconto_percentuale = valore
    
    # Property di sola lettura per il prezzo scontato
    @property
    def prezzo_scontato(self):
        """
        Calcola il prezzo con lo sconto applicato.
        
        Returns:
            float: Il prezzo finale dopo lo sconto
        """
        return self.prezzo * (1 - self.sconto_percentuale / 100)
    
    # Property di sola lettura per il valore inventario
    @property
    def valore_inventario(self):
        """
        Calcola il valore totale dell'inventario.
        
        Returns:
            float: prezzo_scontato * quantita
        """
        return self.prezzo_scontato * self.quantita
    
    def __str__(self):
        """Rappresentazione testuale del prodotto."""
        info = f"{self.nome} - €{self.prezzo:.2f}"
        if self.sconto_percentuale > 0:
            info += f" (sconto {self.sconto_percentuale:.0f}% → €{self.prezzo_scontato:.2f})"
        info += f" x {self.quantita} = €{self.valore_inventario:.2f}"
        return info


# Test della classe
if __name__ == "__main__":
    prodotto = Prodotto("Laptop", 1000.0, 5)
    print(prodotto)
    print()
    
    print("Applicando sconto del 20%...")
    prodotto.sconto_percentuale = 20
    print(f"Prezzo scontato: €{prodotto.prezzo_scontato:.2f}")
    print(f"Valore inventario: €{prodotto.valore_inventario:.2f}")
    print(prodotto)
    print()
    
    print("Modificando il prezzo...")
    prodotto.prezzo = 1200
    print(prodotto)
    print()
    
    # Test validazione
    try:
        print("Tentativo di impostare prezzo negativo...")
        prodotto.prezzo = -50
    except ValueError as e:
        print(f"❌ Errore: {e}")
    
    try:
        print("Tentativo di impostare sconto invalido...")
        prodotto.sconto_percentuale = 150
    except ValueError as e:
        print(f"❌ Errore: {e}")

class Veicolo:
    """Classe base per tutti i veicoli."""
    
    def __init__(self, marca, modello, anno):
        """
        Inizializza un veicolo generico.
        
        Args:
            marca (str): Marca del veicolo
            modello (str): Modello del veicolo
            anno (int): Anno di produzione
        """
        self.marca = marca
        self.modello = modello
        self.anno = anno
    
    def descrizione(self):
        """Restituisce una descrizione del veicolo."""
        return f"{self.marca} {self.modello} ({self.anno})"
    
    def emissioni_co2(self):
        """
        Calcola le emissioni di CO2 in g/km.
        Deve essere implementato dalle sottoclassi.
        """
        raise NotImplementedError("Le sottoclassi devono implementare emissioni_co2()")
    
    def __str__(self):
        return self.descrizione()


class Auto(Veicolo):
    """Rappresenta un'automobile."""
    
    def __init__(self, marca, modello, anno, cilindrata):
        """
        Inizializza un'auto.
        
        Args:
            marca (str): Marca dell'auto
            modello (str): Modello dell'auto
            anno (int): Anno di produzione
            cilindrata (float): Cilindrata del motore in litri
        """
        super().__init__(marca, modello, anno)
        self.cilindrata = cilindrata
    
    def emissioni_co2(self):
        """
        Calcola le emissioni di CO2.
        
        Returns:
            float: Emissioni in g/km (cilindrata * 120)
        """
        return self.cilindrata * 120
    
    def __repr__(self):
        return f"Auto(marca='{self.marca}', modello='{self.modello}', anno={self.anno}, cilindrata={self.cilindrata})"


class Moto(Veicolo):
    """Rappresenta una motocicletta."""
    
    def __init__(self, marca, modello, anno, cilindrata):
        """
        Inizializza una moto.
        
        Args:
            marca (str): Marca della moto
            modello (str): Modello della moto
            anno (int): Anno di produzione
            cilindrata (int): Cilindrata del motore in cc
        """
        super().__init__(marca, modello, anno)
        self.cilindrata = cilindrata
    
    def emissioni_co2(self):
        """
        Calcola le emissioni di CO2.
        
        Returns:
            float: Emissioni in g/km (cilindrata * 0.08)
        """
        return self.cilindrata * 0.08


class VeicoloElettrico(Veicolo):
    """Rappresenta un veicolo elettrico."""
    
    def __init__(self, marca, modello, anno, capacita_batteria):
        """
        Inizializza un veicolo elettrico.
        
        Args:
            marca (str): Marca del veicolo
            modello (str): Modello del veicolo
            anno (int): Anno di produzione
            capacita_batteria (float): Capacità della batteria in kWh
        """
        super().__init__(marca, modello, anno)
        self.capacita_batteria = capacita_batteria
    
    def emissioni_co2(self):
        """
        I veicoli elettrici non hanno emissioni dirette.
        
        Returns:
            float: 0 g/km
        """
        return 0
    
    @property
    def autonomia(self):
        """
        Calcola l'autonomia stimata.
        
        Returns:
            float: Autonomia in km (capacita_batteria * 5)
        """
        return self.capacita_batteria * 5


def confronta_emissioni(veicolo1, veicolo2):
    """
    Confronta le emissioni di CO2 di due veicoli.
    Dimostra il polimorfismo!
    
    Args:
        veicolo1 (Veicolo): Primo veicolo
        veicolo2 (Veicolo): Secondo veicolo
    """
    em1 = veicolo1.emissioni_co2()
    em2 = veicolo2.emissioni_co2()
    
    print(f"
🔍 Confronto Emissioni:")
    print(f"   {veicolo1.descrizione()}: {em1:.1f} g/km CO2")
    print(f"   {veicolo2.descrizione()}: {em2:.1f} g/km CO2")
    
    if em1 < em2:
        print(f"✅ {veicolo1.descrizione()} inquina meno!")
    elif em2 < em1:
        print(f"✅ {veicolo2.descrizione()} inquina meno!")
    else:
        print("⚖️  Entrambi hanno le stesse emissioni!")


# Test delle classi
if __name__ == "__main__":
    auto = Auto("Fiat", "Panda", 2020, 1.2)
    moto = Moto("Ducati", "Monster", 2021, 821)
    elettrica = VeicoloElettrico("Tesla", "Model 3", 2023, 75)
    
    print("🚗 === AUTO ===")
    print(auto)
    print(f"Emissioni: {auto.emissioni_co2():.1f} g/km")
    print(f"Repr: {repr(auto)}")
    
    print("
🏍️  === MOTO ===")
    print(moto)
    print(f"Emissioni: {moto.emissioni_co2():.1f} g/km")
    
    print("
⚡ === VEICOLO ELETTRICO ===")
    print(elettrica)
    print(f"Emissioni: {elettrica.emissioni_co2():.1f} g/km")
    print(f"Autonomia: {elettrica.autonomia:.0f} km")
    
    # Polimorfismo in azione!
    confronta_emissioni(auto, elettrica)
    confronta_emissioni(moto, auto)
    
    # Lista polimorfica
    print("
📊 === TUTTI I VEICOLI ===")
    veicoli = [auto, moto, elettrica]
    for v in veicoli:
        print(f"   {v} → {v.emissioni_co2():.1f} g/km")

import random

class Brano:
    """Rappresenta un brano musicale."""
    
    def __init__(self, titolo, artista, durata_secondi):
        """
        Inizializza un brano.
        
        Args:
            titolo (str): Titolo del brano
            artista (str): Nome dell'artista
            durata_secondi (int): Durata in secondi
        """
        self.titolo = titolo
        self.artista = artista
        self.durata_secondi = durata_secondi
    
    @property
    def durata_formattata(self):
        """
        Restituisce la durata in formato MM:SS.
        
        Returns:
            str: Durata formattata
        """
        minuti = self.durata_secondi // 60
        secondi = self.durata_secondi % 60
        return f"{minuti:02d}:{secondi:02d}"
    
    def __str__(self):
        """Rappresentazione user-friendly."""
        return f"{self.titolo} - {self.artista} ({self.durata_formattata})"
    
    def __repr__(self):
        """Rappresentazione tecnica."""
        return f"Brano(titolo='{self.titolo}', artista='{self.artista}', durata={self.durata_secondi}s)"
    
    def __eq__(self, other):
        """Due brani sono uguali se hanno stesso titolo e artista."""
        if not isinstance(other, Brano):
            return False
        return self.titolo == other.titolo and self.artista == other.artista
    
    def __lt__(self, other):
        """Confronta brani per durata (per ordinamento)."""
        return self.durata_secondi < other.durata_secondi


class Playlist:
    """Gestisce una playlist di brani musicali."""
    
    def __init__(self, nome):
        """
        Inizializza una playlist.
        
        Args:
            nome (str): Nome della playlist
        """
        self.nome = nome
        self.brani = []  # Lista di oggetti Brano
    
    def aggiungi_brano(self, brano):
        """
        Aggiunge un brano alla playlist.
        
        Args:
            brano (Brano): Il brano da aggiungere
        """
        self.brani.append(brano)
        print(f"✅ Aggiunto: {brano.titolo}")
    
    def rimuovi_brano(self, brano):
        """
        Rimuove un brano dalla playlist.
        
        Args:
            brano (Brano): Il brano da rimuovere
        
        Returns:
            bool: True se rimosso, False se non trovato
        """
        if brano in self.brani:
            self.brani.remove(brano)
            print(f"❌ Rimosso: {brano.titolo}")
            return True
        print(f"⚠️  Brano non trovato: {brano.titolo}")
        return False
    
    @property
    def durata_totale(self):
        """
        Calcola la durata totale della playlist in secondi.
        
        Returns:
            int: Durata totale in secondi
        """
        return sum(brano.durata_secondi for brano in self.brani)
    
    @property
    def durata_totale_formattata(self):
        """
        Restituisce la durata totale in formato HH:MM:SS.
        
        Returns:
            str: Durata formattata
        """
        totale = self.durata_totale
        ore = totale // 3600
        minuti = (totale % 3600) // 60
        secondi = totale % 60
        return f"{ore:02d}:{minuti:02d}:{secondi:02d}"
    
    def __len__(self):
        """Restituisce il numero di brani nella playlist."""
        return len(self.brani)
    
    def __getitem__(self, index):
        """Permette l'accesso ai brani tramite indice."""
        return self.brani[index]
    
    def __contains__(self, brano):
        """Permette di usare 'in' per controllare se un brano è nella playlist."""
        return brano in self.brani
    
    def ordina_per_durata(self, reverse=False):
        """
        Ordina i brani per durata.
        
        Args:
            reverse (bool): Se True ordina dal più lungo al più corto
        """
        self.brani.sort(reverse=reverse)
        print(f"🔄 Playlist ordinata per durata ({'decrescente' if reverse else 'crescente'})")
    
    def stampa_playlist(self):
        """Stampa tutti i brani della playlist."""
        print(f"
🎵 === {self.nome.upper()} ===")
        print(f"Brani: {len(self)} | Durata totale: {self.durata_totale_formattata}")
        print("-" * 50)
        for i, brano in enumerate(self.brani, 1):
            print(f"{i:2d}. {brano}")


class PlaylistSmart(Playlist):
    """Playlist con funzionalità avanzate."""
    
    def aggiungi_brano(self, brano):
        """
        Override: non permette duplicati.
        
        Args:
            brano (Brano): Il brano da aggiungere
        
        Returns:
            bool: True se aggiunto, False se duplicato
        """
        if brano in self.brani:
            print(f"⚠️  Brano già presente: {brano.titolo}")
            return False
        super().aggiungi_brano(brano)  # Chiama il metodo della classe base
        return True
    
    def shuffle(self):
        """Mescola casualmente l'ordine dei brani."""
        random.shuffle(self.brani)
        print("🔀 Playlist mescolata casualmente!")
    
    @property
    def brano_piu_lungo(self):
        """
        Restituisce il brano più lungo della playlist.
        
        Returns:
            Brano: Il brano con durata maggiore, None se playlist vuota
        """
        if not self.brani:
            return None
        return max(self.brani, key=lambda b: b.durata_secondi)


# ========================================
# TEST COMPLETO DEL SISTEMA
# ========================================

if __name__ == "__main__":
    # Creiamo alcuni brani
    print("🎸 Creazione brani...")
    brano1 = Brano("Bohemian Rhapsody", "Queen", 354)
    brano2 = Brano("Stairway to Heaven", "Led Zeppelin", 482)
    brano3 = Brano("Hotel California", "Eagles", 391)
    brano4 = Brano("Comfortably Numb", "Pink Floyd", 382)
    brano5 = Brano("Sweet Child O' Mine", "Guns N' Roses", 356)
    
    # Creiamo una playlist smart
    print("
📝 Creazione playlist...")
    playlist = PlaylistSmart("Rock Classics")
    
    # Aggiungiamo brani
    print("
➕ Aggiunta brani...")
    playlist.aggiungi_brano(brano1)
    playlist.aggiungi_brano(brano2)
    playlist.aggiungi_brano(brano3)
    playlist.aggiungi_brano(brano4)
    playlist.aggiungi_brano(brano5)
    
    # Test duplicati
    print("
🔁 Test duplicati...")
    playlist.aggiungi_brano(brano1)  # Non verrà aggiunto
    
    # Mostriamo la playlist
    playlist.stampa_playlist()
    
    # Test operatori speciali
    print("
🔍 Test operatori speciali...")
    print(f"Numero di brani: {len(playlist)}")
    print(f"Primo brano: {playlist[0]}")
    print(f"Bohemian Rhapsody è nella playlist? {brano1 in playlist}")
    
    # Brano più lungo
    print("
⏱️  Brano più lungo...")
    print(f"Il brano più lungo è: {playlist.brano_piu_lungo}")
    
    # Ordiniamo
    print("
📊 Ordinamento...")
    playlist.ordina_per_durata(reverse=True)
    playlist.stampa_playlist()
    
    # Shuffle
    print("
🎲 Mescolamento casuale...")
    playlist.shuffle()
    playlist.stampa_playlist()
    
    # Rimozione
    print("
➖ Rimozione brano...")
    playlist.rimuovi_brano(brano3)
    playlist.stampa_playlist()
    
    print("
✅ Test completato!")